home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / libpng / pngtest.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-12  |  10.0 KB  |  378 lines
  1.  
  2. /* pngtest.c - a simple test program to test libpng
  3.  
  4.    libpng 1.0 beta 6 - version 0.96
  5.    For conditions of distribution and use, see copyright notice in png.h
  6.    Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  7.    Copyright (c) 1996, 1997 Andreas Dilger
  8.    May 12, 1997
  9.    */
  10.  
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13.  
  14. /* Makes pngtest verbose so we can find problems (needs to be before png.h) */
  15. #ifndef PNG_DEBUG
  16. #define PNG_DEBUG 0
  17. #endif
  18.  
  19. #include "png.h"
  20.  
  21. #ifdef __TURBOC__
  22. #include <mem.h>
  23. #endif
  24.  
  25. /* defined so I can write to a file on gui/windowing platforms */
  26. /*  #define STDERR stderr  */
  27. #define STDERR stdout   /* for DOS */
  28.  
  29. /* input and output filenames */
  30. #ifdef RISCOS
  31. char *inname = "pngtest_png";
  32. char *outname = "pngout_png";
  33. #else
  34. char *inname = "pngtest.png";
  35. char *outname = "pngout.png";
  36. #endif
  37.  
  38. char inbuf[256], outbuf[256];
  39.  
  40. int
  41. main(int argc, char *argv[])
  42. {
  43.    FILE *fpin, *fpout;
  44.    png_structp read_ptr, write_ptr;
  45.    png_infop read_info_ptr, write_info_ptr, end_info_ptr;
  46.    png_bytep row_buf;
  47.    png_uint_32 y;
  48.    png_uint_32 width, height;
  49.    int num_pass, pass;
  50.    int bit_depth, color_type;
  51. #ifdef USE_FAR_KEYWORD
  52.    jmp_buf jmpbuf;
  53. #endif   
  54.    row_buf = (png_bytep)NULL;
  55.  
  56.    fprintf(STDERR, "Testing libpng version %s\n", PNG_LIBPNG_VER_STRING);
  57.  
  58.    if (strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING))
  59.    {
  60.       fprintf(STDERR,
  61.          "Warning: versions are different between png.h and png.c\n");
  62.       fprintf(STDERR, "  png.h version: %s\n", PNG_LIBPNG_VER_STRING);
  63.       fprintf(STDERR, "  png.c version: %s\n\n", png_libpng_ver);
  64.    }
  65.  
  66.    if (argc > 1)
  67.      inname = argv[1];
  68.  
  69.    if (argc > 2)
  70.      outname = argv[2];
  71.  
  72.    if (argc > 3)
  73.    {
  74.      fprintf(stderr, "usage: %s [infile.png] [outfile.png]\n", argv[0]);
  75.      exit(1);
  76.    }
  77.  
  78.    if ((fpin = fopen(inname, "rb")) == NULL)
  79.    {
  80.       fprintf(STDERR, "Could not find input file %s\n", inname);
  81.       return 1;
  82.    }
  83.  
  84.    if ((fpout = fopen(outname, "wb")) == NULL)
  85.    {
  86.       fprintf(STDERR, "Could not open output file %s\n", outname);
  87.       fclose(fpin);
  88.       return 1;
  89.    }
  90.  
  91.    png_debug(0, "Allocating read and write structures\n");
  92.    read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
  93.       (png_error_ptr)NULL, (png_error_ptr)NULL);
  94.    write_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
  95.       (png_error_ptr)NULL, (png_error_ptr)NULL);
  96.    png_debug(0, "Allocating read_info, write_info and end_info structures\n");
  97.    read_info_ptr = png_create_info_struct(read_ptr);
  98.    write_info_ptr = png_create_info_struct(read_ptr);
  99.    end_info_ptr = png_create_info_struct(read_ptr);
  100.  
  101.    png_debug(0, "Setting jmpbuf for read struct\n");
  102. #ifdef USE_FAR_KEYWORD
  103.    if (setjmp(jmpbuf))
  104. #else
  105.    if (setjmp(read_ptr->jmpbuf))
  106. #endif
  107.    {
  108.       fprintf(STDERR, "libpng read error\n");
  109.       png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
  110.       png_destroy_write_struct(&write_ptr, &write_info_ptr);
  111.       fclose(fpin);
  112.       fclose(fpout);
  113.       return 1;
  114.    }
  115.  
  116.    png_debug(0, "Setting jmpbuf for write struct\n");
  117. #ifdef USE_FAR_KEYWORD
  118.    png_memcpy(read_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf));
  119.    if (setjmp(jmpbuf))
  120. #else
  121.    if (setjmp(write_ptr->jmpbuf))
  122. #endif
  123.    {
  124.       fprintf(STDERR, "libpng write error\n");
  125.       png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
  126.       png_destroy_write_struct(&write_ptr, &write_info_ptr);
  127.       fclose(fpin);
  128.       fclose(fpout);
  129.       return 1;
  130.    }
  131.  
  132. #ifdef USE_FAR_KEYWORD
  133.    png_memcpy(write_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf));
  134. #endif
  135.    png_debug(0, "Initializing input and output streams\n");
  136.    png_init_io(read_ptr, fpin);
  137.    png_init_io(write_ptr, fpout);
  138.  
  139.    png_debug(0, "Reading info struct\n");
  140.    png_read_info(read_ptr, read_info_ptr);
  141.  
  142.    png_debug(0, "Transferring info struct\n");
  143.    {
  144.       int interlace_type, compression_type, filter_type;
  145.  
  146.       if (png_get_IHDR(read_ptr, read_info_ptr, &width, &height, &bit_depth,
  147.           &color_type, &interlace_type, &compression_type, &filter_type))
  148.       {
  149.          png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth,
  150.             color_type, interlace_type, compression_type, filter_type);
  151.       }
  152.    }
  153. #if defined(PNG_READ_bKGD_SUPPORTED) && defined(PNG_WRITE_bKGD_SUPPORTED)
  154.    {
  155.       png_color_16p background;
  156.  
  157.       if (png_get_bKGD(read_ptr, read_info_ptr, &background))
  158.       {
  159.          png_set_bKGD(write_ptr, write_info_ptr, background);
  160.       }
  161.    }
  162. #endif
  163. #if defined(PNG_READ_cHRM_SUPPORTED) && defined(PNG_WRITE_cHRM_SUPPORTED)
  164.    {
  165.       double white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;
  166.  
  167.       if (png_get_cHRM(read_ptr, read_info_ptr, &white_x, &white_y, &red_x,
  168.          &red_y, &green_x, &green_y, &blue_x, &blue_y))
  169.       {
  170.          png_set_cHRM(write_ptr, write_info_ptr, white_x, white_y, red_x,
  171.             red_y, green_x, green_y, blue_x, blue_y);
  172.       }
  173.    }
  174. #endif
  175. #if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_WRITE_gAMA_SUPPORTED)
  176.    {
  177.       double gamma;
  178.  
  179.       if (png_get_gAMA(read_ptr, read_info_ptr, &gamma))
  180.       {
  181.          png_set_gAMA(write_ptr, write_info_ptr, gamma);
  182.       }
  183.    }
  184. #endif
  185. #if defined(PNG_READ_hIST_SUPPORTED) && defined(PNG_WRITE_hIST_SUPPORTED)
  186.    {
  187.       png_uint_16p hist;
  188.  
  189.       if (png_get_hIST(read_ptr, read_info_ptr, &hist))
  190.       {
  191.          png_set_hIST(write_ptr, write_info_ptr, hist);
  192.       }
  193.    }
  194. #endif
  195. #if defined(PNG_READ_oFFs_SUPPORTED) && defined(PNG_WRITE_oFFs_SUPPORTED)
  196.    {
  197.       png_uint_32 offset_x, offset_y;
  198.       int unit_type;
  199.  
  200.       if (png_get_oFFs(read_ptr, read_info_ptr,&offset_x,&offset_y,&unit_type))
  201.       {
  202.          png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type);
  203.       }
  204.    }
  205. #endif
  206. #if defined(PNG_READ_pCAL_SUPPORTED) && defined(PNG_WRITE_pCAL_SUPPORTED)
  207.    {
  208.       png_charp purpose, units;
  209.       png_charpp params;
  210.       png_int_32 X0, X1;
  211.       int type, nparams;
  212.  
  213.       if (png_get_pCAL(read_ptr, read_info_ptr, &purpose, &X0, &X1, &type,
  214.          &nparams, &units, ¶ms))
  215.       {
  216.          png_set_pCAL(write_ptr, write_info_ptr, purpose, X0, X1, type,
  217.             nparams, units, params);
  218.       }
  219.    }
  220. #endif
  221. #if defined(PNG_READ_pHYs_SUPPORTED) && defined(PNG_WRITE_pHYs_SUPPORTED)
  222.    {
  223.       png_uint_32 res_x, res_y;
  224.       int unit_type;
  225.  
  226.       if (png_get_pHYs(read_ptr, read_info_ptr, &res_x, &res_y, &unit_type))
  227.       {
  228.          png_set_pHYs(write_ptr, write_info_ptr, res_x, res_y, unit_type);
  229.       }
  230.    }
  231. #endif
  232.    {
  233.       png_colorp palette;
  234.       int num_palette;
  235.  
  236.       if (png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette))
  237.       {
  238.          png_set_PLTE(write_ptr, write_info_ptr, palette, num_palette);
  239.       }
  240.    }
  241. #if defined(PNG_READ_sBIT_SUPPORTED) && defined(PNG_WRITE_sBIT_SUPPORTED)
  242.    {
  243.       png_color_8p sig_bit;
  244.  
  245.       if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit))
  246.       {
  247.          png_set_sBIT(write_ptr, write_info_ptr, sig_bit);
  248.       }
  249.    }
  250. #endif
  251. #if (defined(PNG_READ_tEXt_SUPPORTED) && defined(PNG_WRITE_tEXt_SUPPORTED)) || \
  252.     (defined(PNG_READ_zTXt_SUPPORTED) && defined(PNG_WRITE_zTXt_SUPPORTED))
  253.    {
  254.       png_textp text_ptr;
  255.       int num_text;
  256.  
  257.       if (png_get_text(read_ptr, read_info_ptr, &text_ptr, &num_text) > 0)
  258.       {
  259.          png_debug1(0, "Handling %d tEXt/zTXt chunks\n", num_text);
  260.          png_set_text(write_ptr, write_info_ptr, text_ptr, num_text);
  261.       }
  262.    }
  263. #endif
  264. #if defined(PNG_READ_tIME_SUPPORTED) && defined(PNG_WRITE_tIME_SUPPORTED)
  265.    {
  266.       png_timep mod_time;
  267.  
  268.       if (png_get_tIME(read_ptr, read_info_ptr, &mod_time))
  269.       {
  270.          png_set_tIME(write_ptr, write_info_ptr, mod_time);
  271.       }
  272.    }
  273. #endif
  274. #if defined(PNG_READ_tRNS_SUPPORTED) && defined(PNG_WRITE_tRNS_SUPPORTED)
  275.    {
  276.       png_bytep trans;
  277.       int num_trans;
  278.       png_color_16p trans_values;
  279.  
  280.       if (png_get_tRNS(read_ptr, read_info_ptr, &trans, &num_trans,
  281.          &trans_values))
  282.       {
  283.          png_set_tRNS(write_ptr, write_info_ptr, trans, num_trans,
  284.             trans_values);
  285.       }
  286.    }
  287. #endif
  288.  
  289.    png_debug(0, "\nWriting info struct\n");
  290.    png_write_info(write_ptr, write_info_ptr);
  291.  
  292.    row_buf = (png_bytep)png_malloc(read_ptr, 
  293.       png_get_rowbytes(read_ptr, read_info_ptr));
  294.    if (row_buf == NULL)
  295.    {
  296.       fprintf(STDERR, "No memory to allocate row buffer\n");
  297.       png_destroy_read_struct(&read_ptr, &read_info_ptr, (png_infopp)NULL);
  298.       png_destroy_write_struct(&write_ptr, &write_info_ptr);
  299.       fclose(fpin);
  300.       fclose(fpout);
  301.       return 1;
  302.    }
  303.  
  304.    num_pass = png_set_interlace_handling(read_ptr);
  305.    png_set_interlace_handling(write_ptr);
  306.  
  307.    for (pass = 0; pass < num_pass; pass++)
  308.    {
  309.       for (y = 0; y < height; y++)
  310.       {
  311.          png_read_rows(read_ptr, (png_bytepp)&row_buf, (png_bytepp)NULL, 1);
  312.          png_write_rows(write_ptr, (png_bytepp)&row_buf, 1);
  313.       }
  314.    }
  315.  
  316.    png_debug(0, "Reading and writing end_info data\n");
  317.    png_read_end(read_ptr, end_info_ptr);
  318.    png_write_end(write_ptr, end_info_ptr);
  319.  
  320.    png_debug(0, "Destroying data structs\n");
  321.    png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr);
  322.    png_destroy_write_struct(&write_ptr, &write_info_ptr);
  323.  
  324.    fclose(fpin);
  325.    fclose(fpout);
  326.  
  327.    png_free(read_ptr, row_buf);
  328.  
  329.    png_debug(0, "Opening files for comparison\n");
  330.    if ((fpin = fopen(inname, "rb")) == NULL)
  331.    {
  332.       fprintf(STDERR, "Could not find file %s\n", inname);
  333.       return 1;
  334.    }
  335.  
  336.    if ((fpout = fopen(outname, "rb")) == NULL)
  337.    {
  338.       fprintf(STDERR, "Could not find file %s\n", outname);
  339.       fclose(fpin);
  340.       return 1;
  341.    }
  342.  
  343.    while (1)
  344.    {
  345.       png_size_t num_in, num_out;
  346.  
  347.       num_in = fread(inbuf, 1, 1, fpin);
  348.       num_out = fread(outbuf, 1, 1, fpout);
  349.  
  350.       if (num_in != num_out)
  351.       {
  352.          fprintf(STDERR, "Files %s and %s are of a different size\n",
  353.                  inname, outname);
  354.          fclose(fpin);
  355.          fclose(fpout);
  356.          return 1;
  357.       }
  358.  
  359.       if (!num_in)
  360.          break;
  361.  
  362.       if (png_memcmp(inbuf, outbuf, num_in))
  363.       {
  364.          fprintf(STDERR, "Files %s and %s are different\n", inname, outname);
  365.          fclose(fpin);
  366.          fclose(fpout);
  367.          return 1;
  368.       }
  369.    }
  370.  
  371.    fclose(fpin);
  372.    fclose(fpout);
  373.    fprintf(STDERR, "libpng passes test\n");
  374.  
  375.    return 0;
  376. }
  377.  
  378.